/**
 * 演示匿名函数嵌套匿名函数
 */

fn main() {
    simple_nesting();
    simple_nesting1();
}
/**
 * 使用原始指针让i32变为可变的，然后乘以2
 */
fn double(x: *mut i32) {
    unsafe {
        *x = 2 * (*x);
    }
}

/**
 * 一个简单的匿名函数嵌套例子
 */
fn simple_nesting() {
    let fadd = |x: i32, y: i32| x + y;
    let fsub = |x: i32, y: i32| x - y;
    let fmix = |x: i32, y: i32| fadd(x, fsub(x, y));

    let a = 100;
    let b = 20;
    println!("{}", fmix(a, b));
    println!("{a},{b}");
    println!("------------------------------------");
    println!("------------------------------------");
}

/**
 * 一个简单的匿名函数嵌套例子
 */
fn simple_nesting1() {
    let fadd = |x: i32, y: i32| -> i32 { x + y };
    let fsub = |x: i32, y: i32| -> i32 { x - y };
    let fmix = |x: *mut i32, y: i32| -> i32 {
        unsafe {
            *x = fadd(*x, fsub(*x, y));
            println!("{},{}", *x, y);
            *x * 2
        }
    };

    //a必须是可变，否则即使fmix的一个参数是mut，也不会生效。
    //因为a,b是i32的类型，传递的时候默认是拷贝，拷贝是不可变的。
    let mut a = 100;
    let raw_a = &mut a as *mut i32;
    let b = 20;
    let c = fmix(raw_a, b);
    println!("{}", c);
    println!("{a},{b}");
    double(raw_a);
    println!("{a}");
}

#[derive(Debug)]
struct Face{
    score:i32,
}

/**
 * 真的是有问题吗？ 没有的
 */
fn wrong_nesting() {
    //等待找到吧！
    let mut x = Face{score:10};
    // 外部闭包
    let mut  outer_closure = || {
        // 内部闭包
        let  mut  inner_closure = || {
            x.score += 1;
            println!("x = {:?}", x); 
        };
        inner_closure();
    };
    outer_closure();
}
